rochars / wavefile

 * wavefile

 * Read & write wave files with 8, 16, 24, 32 PCM, 32 IEEE & 64-bit data.

 * Copyright (c) 2017 Rafael da Silva Rocha. MIT License.

 * https://github.com/rochars/wavefile

 *

 */

const bitDepthLib = require("bitdepth");

const wavefile = require("../src/wavefile");

/**

 * A wave file.

 */

class WaveFileInterface extends wavefile.WaveFile {

    /**

     * @param {Uint8Array} bytes The file bytes.

     * @param {boolean} enforceFact True if it should throw a error

     *      if no "fact" chunk is found.

     * @param {boolean} enforceBext True if it should throw a error

     *      if no "bext" chunk is found.

     */

    /**

     * Create a WaveFile object based on the arguments passed.

     * @param {number} numChannels The number of channels

     *     (Ints like 1 for mono, 2 stereo and so on).

     * @param {number} sampleRate The sample rate.

     *     Integer numbers like 8000, 44100, 48000, 96000, 192000.

     * @param {string} bitDepth The audio bit depth.

     *     One of "8", "16", "24", "32", "32f", "64".

     * @param {!Array<number>} samples Array of samples to be written.

     *     Samples must be in the correct range according to the bit depth.

     *     Samples of multi-channel data .

     */

    fromScratch(numChannels, sampleRate, bitDepth, samples, options={}) {

        if (!options.container) {

            options.container = "RIFF";

        }

        this.isFromScratch_ = true;

        let bytes = parseInt(bitDepth, 10) / 8;

        this.chunkSize = 36 + samples.length * bytes;

        this.subChunk1Size = 16;

        this.byteRate = (numChannels * bytes) * sampleRate;

        this.blockAlign = numChannels * bytes;

        this.chunkId = options.container;

        this.format = "WAVE";

        this.subChunk1Id = "fmt ";

        this.audioFormat = this.headerFormats_[bitDepth];

        this.numChannels = numChannels;

        this.sampleRate = sampleRate;

        this.bitsPerSample = parseInt(bitDepth, 10);

        this.subChunk2Id = "data";

        this.subChunk2Size = samples.length * bytes;

        this.samples_ = samples;

        this.bitDepth_ = bitDepth;

    }

    /**

     * Read a wave file from a byte buffer.

     * @param {Uint8Array} bytes The buffer.

     */

    fromBuffer(bytes) {

        this.isFromScratch_ = false;

        this.readRIFFChunk_(bytes);

        this.readWAVEChunk_(bytes);

        this.readFmtChunk_(bytes);

        this.readFactChunk_(bytes);

        this.readBextChunk_(bytes);

        this.readDataChunk_(bytes);

    }

    /**

     * Turn the WaveFile object into a byte buffer.

     * @return {Uint8Array}

     */

    toBuffer() {

        this.checkWriteInput_(this.numChannels, this.sampleRate, this.bitDepth_);

        this.samplesToBytes_();

        return new Uint8Array(this.createWaveFile_());

    }

    /**

     * Turn the file to RIFF.

     * All values will be little-endian when writing.

     */

    toRIFF() {

        this.chunkId = "RIFF";

    }

    /**

     * Turn the file to RIFX.

     * All values but FourCCs will be big-endian when writing.

     */

    toRIFX() {

        this.chunkId = "RIFX";

    }

    /**

     * Change the bit depth of the data.

     * @param {string} bitDepth The new bit depth of the data.

     *      One of "8", "16", "24", "32", "32f", "64"

     */

    toBitDepth(bitDepth) {

        bitDepthLib.toBitDepth(this.samples_, this.bitDepth_, bitDepth);

        this.fromScratch(

            this.numChannels,

            this.sampleRate,

            bitDepth,

            this.samples_,

            {"container": this.chunkId}

        );

    }

    /**

     * Interleave multi-channel samples.

     */

    interleave() {

        let finalSamples = [];

        let i;

        let j;

        let numChannels = this.samples_[0].length;

        for (i = 0; i < numChannels; i++) {

            for (j = 0; j < this.samples_.length; j++) {

                finalSamples.push(this.samples_[j][i]);

            }

        }

        this.samples_ = finalSamples;

    }

    /**

     * De-interleave samples into multiple channels.

     */

    deInterleave() {

        let finalSamples = [];

        let i;

        for (i = 0; i < this.numChannels; i++) {

            finalSamples[i] = [];

        }

        i = 0;

        let j;

        while (i < this.samples_.length) {

            for (j = 0; j < this.numChannels; j++) {

                finalSamples[j].push(this.samples_[i+j]);

            }

            i += j;

        }

        this.samples_ = finalSamples;

    }

}